spring cloud 简单的分布式日志追踪实现

JAVA/ web后端 JAVA spring

创建时间:2019-02-01 21:10

字数:1.3k 阅读:

评论:

项目情况介绍
解决的问题
思路
实现

项目情况介绍

项目架构：基本的 spring cloud 微服务架构，包括网关、注册中心、配置中心、两个基础服务（基于 feign 调用）。

一张图表示一下

其中 backend 调用 usercenter。

解决的问题

实现简单的分布式日志追踪（用户的一个请求可能穿插于多个服务之间，多个服务的日志都被唯一标识链接）

思路

spring cloud zuul gateway 提供了丰富的请求拦截器对每个请求做相应的处理。
feign 也提供了拦截器对每个请求做相应的处理。
利用拦截器在请求头中放置 tack-id 做日志追踪处理。
logback mdc 采用 ThreadLocal 存储用户数据，不同请求不会相互影响。

实现

gateway 请求拦截器，生成追踪信息

TrackingFilter

@Slf4j
@Component
public class TrackingFilter extends ZuulFilter {
    private static final int FILTER_ORDER = 1;
    private static final boolean SHOULD_FILTER = true;

    @Override
    public String filterType() {
        //告诉 Zuul 过滤器是一个前置，路由或后置过滤器。
        // pre
        return GatewayConstant.PRE_FILTER_TYPE;
    }

    @Override
    public int filterOrder() {
        //返回一个整型值表示 Zuul 应该通过不同的过滤器类型发送请求的顺序。
        return FILTER_ORDER;
    }

    @Override
    public boolean shouldFilter() {
        //返回一个布尔值，表示过滤器是否应该处于活动状态
        return SHOULD_FILTER;
    }

    @Override
    public Object run() {
        if (FilterUtil.getLogTrackId() != null) {
            log.debug("发现日志追踪 id : {}.", FilterUtil.getLogTrackId());
        } else {
            FilterUtil.setLogTrackId(java.util.UUID.randomUUID().toString());
            log.debug("生成日志追踪 id : {}.", FilterUtil.getLogTrackId());
        }
        return null;
    }
}

FilterUtil

public class FilterUtil {
    public static String getLogTrackId() {
        RequestContext ctx = RequestContext.getCurrentContext();

        if (ctx.getRequest().getHeader(GatewayConstant.LOG_TRACK_ID) != null) {
            return ctx.getRequest().getHeader(GatewayConstant.LOG_TRACK_ID);
        } else {
            return ctx.getZuulRequestHeaders().get(GatewayConstant.LOG_TRACK_ID);
        }
    }

    public static void setLogTrackId(String correlationId) {
        RequestContext ctx = RequestContext.getCurrentContext();
        ctx.addZuulRequestHeader(GatewayConstant.LOG_TRACK_ID, correlationId);
    }
}

服务中的请求拦截器，获取追踪信息

LogTrackingFilter

@Slf4j
@Component
public class LogTrackingFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
            throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
        //从请求头获取关联id
        String header = httpServletRequest.getHeader(GatewayConstant.LOG_TRACK_ID);
        //放置关联id
        MDC.put(GatewayConstant.LOG_TRACK_ID, header);
        //缓存关联id
        UserContextHolder.getContext().setLogTrackId(header);
        log.debug("License Service Incoming Correlation id: {}", UserContextHolder.getContext().getLogTrackId());
        filterChain.doFilter(httpServletRequest, servletResponse);
    }
}

UserContextHolder

public class UserContextHolder {
    private static final ThreadLocal<UserContext> userContext = new ThreadLocal<>();

    public static UserContext getContext() {
        UserContext context = userContext.get();
        if (context == null) {
            context = new UserContext();
            userContext.set(context);
        }
        return userContext.get();
    }

    public static void setContext(UserContext context) {
        Assert.notNull(context, "Only non-null UserContext instances are permitted");
        userContext.set(context);
    }
}

UserContext

@Data
public class UserContext {
    private String logTrackId;
}

feign 的请求拦截器，服务之间传递追踪信息

@Slf4j
@Component
public class FeignClientInterceptor implements RequestInterceptor {

    @Override
    public void apply(RequestTemplate template) {
        ServletRequestAttributes attrs = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attrs != null) {
            HttpServletRequest request = attrs.getRequest();
            String logTrackId = request.getHeader(GatewayConstant.LOG_TRACK_ID);
            //放在请求头中传递关联id
            template.header(GatewayConstant.LOG_TRACK_ID, logTrackId);
        }
    }
}

logback mdc 打印关联id

在 LogTrackingFilter 中通过 MDC.put(GatewayConstant.LOG_TRACK_ID, header); 放置了关联id，通过以下配置在日志中展示

  <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>Debug</level>
        </filter>
        <encoder>
            <charset>UTF-8</charset>
            <Pattern>%blue(%d) %highlight(%-5level) [%thread] [%X{log-track-id}] %cyan(%logger): %msg%n</Pattern>
        </encoder>
    </appender>

测试结果

一张图表示一下

存在的问题

在开启熔断器之后，熔断器默认的隔离策略是 thread ， feign 拦截器在执行 ServletRequestAttributes attrs = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes(); 获取关是为空的，导致服务之间调用传递关联 id 失败。这时候就需要自定义策略将 父线程的数据传递到子线程 。

一张图表示一下

优化改进

上面说到需要将 父线程的数据传递到子线程 ，Hystrix 也提供了自定义策略来完成我们各种各样的业务需求。本章方法重点参考此博客，详情请点击

代码实现

//自定义的包装器接口
public interface HystrixCallableWrapper {
    /**
     * 包装Callable实例
     *
     * @param callable 待包装实例
     * @param <T>      返回类型
     * @return 包装后的实例
     */
    <T> Callable<T> wrap(Callable<T> callable);
}

//请求参数包装器
@Component
public class RequestAttributeAwareCallableWrapper implements HystrixCallableWrapper {

    @Override
    public <T> Callable<T> wrap(Callable<T> callable) {
        return new RequestAttributeAwareCallable<>(callable, RequestContextHolder.getRequestAttributes());
    }

    static class RequestAttributeAwareCallable<T> implements Callable<T> {

        private final Callable<T> delegate;
        private final RequestAttributes requestAttributes;

        RequestAttributeAwareCallable(Callable<T> callable, RequestAttributes requestAttributes) {
            this.delegate = callable;
            this.requestAttributes = requestAttributes;
        }

        @Override
        public T call() throws Exception {
            try {
                RequestContextHolder.setRequestAttributes(requestAttributes);
                return delegate.call();
            } finally {
                RequestContextHolder.resetRequestAttributes();
            }
        }
    }
}

//传递 MDC 日志参数的包装器
@Component
public class MdcAwareCallableWrapper implements HystrixCallableWrapper {

    @Override
    public <T> Callable<T> wrap(Callable<T> callable) {
        return new MdcAwareCallable<>(callable, MDC.getCopyOfContextMap());
    }

    private class MdcAwareCallable<T> implements Callable<T> {

        private final Callable<T> delegate;

        private final Map<String, String> contextMap;

        public MdcAwareCallable(Callable<T> callable, Map<String, String> contextMap) {
            this.delegate = callable;
            this.contextMap = contextMap != null ? contextMap : new HashMap();
        }

        @Override
        public T call() throws Exception {
            try {
                MDC.setContextMap(contextMap);
                return delegate.call();
            } finally {
                MDC.clear();
            }
        }
    }
}

//自定义策略插件
@Component
public class RequestContextHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {

    @Resource
    private List<HystrixCallableWrapper> wrappers;

    @PostConstruct
    private void init() {
        //加载插件需要清除原有策略插件
        HystrixPlugins.reset();
        HystrixPlugins.getInstance().registerConcurrencyStrategy(this);
    }

    @Override
    public <T> Callable<T> wrapCallable(Callable<T> callable) {
        return new CallableWrapperChain<>(callable, wrappers.iterator()).wrapCallable();
    }

    private static class CallableWrapperChain<T> {

        private final Callable<T> callable;

        private final Iterator<HystrixCallableWrapper> wrappers;

        CallableWrapperChain(Callable<T> callable, Iterator<HystrixCallableWrapper> wrappers) {
            this.callable = callable;
            this.wrappers = wrappers;
        }

        Callable<T> wrapCallable() {
            Callable<T> delegate = callable;
            while (wrappers.hasNext()) {
                delegate = wrappers.next().wrap(delegate);
            }
            return delegate;
        }
    }
}